{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = np.sin(x_mesh+y_mesh*5)+np.exp(-x_mesh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.contour.QuadContourSet at 0x1b70555f640>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.contourf(x_domain, y_domain, truth_smooth,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = truth_smooth + np.random.normal(loc=0.0, scale=0.2, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.69991 | domain_loss:  558.45874 | bdc_loss:    1.12659\n",
      "epoch:  200.00000 | total_loss:    2.31111 | domain_loss:  123.40530 | bdc_loss:    1.08794\n",
      "epoch:  400.00000 | total_loss:    1.45104 | domain_loss:   40.81027 | bdc_loss:    1.05347\n",
      "epoch:  600.00000 | total_loss:    1.18760 | domain_loss:   17.63552 | bdc_loss:    1.02146\n",
      "epoch:  800.00000 | total_loss:    1.07343 | domain_loss:    9.25747 | bdc_loss:    0.99076\n",
      "epoch: 1000.00000 | total_loss:    1.00754 | domain_loss:    5.66384 | bdc_loss:    0.96051\n",
      "epoch: 1200.00000 | total_loss:    0.95975 | domain_loss:    3.89623 | bdc_loss:    0.93009\n",
      "epoch: 1400.00000 | total_loss:    0.91939 | domain_loss:    2.92231 | bdc_loss:    0.89916\n",
      "epoch: 1600.00000 | total_loss:    0.88223 | domain_loss:    2.32348 | bdc_loss:    0.86767\n",
      "epoch: 1800.00000 | total_loss:    0.84674 | domain_loss:    1.91375 | bdc_loss:    0.83596\n",
      "epoch: 2000.00000 | total_loss:    0.81282 | domain_loss:    1.60855 | bdc_loss:    0.80478\n",
      "epoch: 2200.00000 | total_loss:    0.78117 | domain_loss:    1.37008 | bdc_loss:    0.77522\n",
      "epoch: 2400.00000 | total_loss:    0.75281 | domain_loss:    1.18114 | bdc_loss:    0.74849\n",
      "epoch: 2600.00000 | total_loss:    0.72865 | domain_loss:    1.03177 | bdc_loss:    0.72559\n",
      "epoch: 2800.00000 | total_loss:    0.70914 | domain_loss:    0.91335 | bdc_loss:    0.70708\n",
      "epoch: 3000.00000 | total_loss:    0.69409 | domain_loss:    0.81789 | bdc_loss:    0.69284\n",
      "epoch: 3200.00000 | total_loss:    0.68277 | domain_loss:    0.73955 | bdc_loss:    0.68219\n",
      "epoch: 3400.00000 | total_loss:    0.67408 | domain_loss:    0.67516 | bdc_loss:    0.67407\n",
      "epoch: 3600.00000 | total_loss:    0.66692 | domain_loss:    0.62318 | bdc_loss:    0.66736\n",
      "epoch: 3800.00000 | total_loss:    0.66033 | domain_loss:    0.58241 | bdc_loss:    0.66111\n",
      "epoch: 4000.00000 | total_loss:    0.65362 | domain_loss:    0.55145 | bdc_loss:    0.65465\n",
      "epoch: 4200.00000 | total_loss:    0.64633 | domain_loss:    0.52874 | bdc_loss:    0.64751\n",
      "epoch: 4400.00000 | total_loss:    0.63809 | domain_loss:    0.51280 | bdc_loss:    0.63935\n",
      "epoch: 4600.00000 | total_loss:    0.62856 | domain_loss:    0.50235 | bdc_loss:    0.62983\n",
      "epoch: 4800.00000 | total_loss:    0.61734 | domain_loss:    0.49634 | bdc_loss:    0.61857\n",
      "epoch: 5000.00000 | total_loss:    0.60395 | domain_loss:    0.49383 | bdc_loss:    0.60507\n",
      "epoch: 5200.00000 | total_loss:    0.58777 | domain_loss:    0.49389 | bdc_loss:    0.58872\n",
      "epoch: 5400.00000 | total_loss:    0.56807 | domain_loss:    0.49539 | bdc_loss:    0.56881\n",
      "epoch: 5600.00000 | total_loss:    0.54409 | domain_loss:    0.49703 | bdc_loss:    0.54457\n",
      "epoch: 5800.00000 | total_loss:    0.51519 | domain_loss:    0.49762 | bdc_loss:    0.51537\n",
      "epoch: 6000.00000 | total_loss:    0.48110 | domain_loss:    0.49680 | bdc_loss:    0.48094\n",
      "epoch: 6200.00000 | total_loss:    0.44216 | domain_loss:    0.49569 | bdc_loss:    0.44162\n",
      "epoch: 6400.00000 | total_loss:    0.39944 | domain_loss:    0.49661 | bdc_loss:    0.39845\n",
      "epoch: 6600.00000 | total_loss:    0.35466 | domain_loss:    0.50148 | bdc_loss:    0.35317\n",
      "epoch: 6800.00000 | total_loss:    0.30991 | domain_loss:    0.51014 | bdc_loss:    0.30789\n",
      "epoch: 7000.00000 | total_loss:    0.26729 | domain_loss:    0.52144 | bdc_loss:    0.26472\n",
      "epoch: 7200.00000 | total_loss:    0.22859 | domain_loss:    0.53554 | bdc_loss:    0.22549\n",
      "epoch: 7400.00000 | total_loss:    0.19515 | domain_loss:    0.55357 | bdc_loss:    0.19153\n",
      "epoch: 7600.00000 | total_loss:    0.16771 | domain_loss:    0.57591 | bdc_loss:    0.16359\n",
      "epoch: 7800.00000 | total_loss:    0.14637 | domain_loss:    0.60218 | bdc_loss:    0.14177\n",
      "epoch: 8000.00000 | total_loss:    0.13061 | domain_loss:    0.63195 | bdc_loss:    0.12555\n",
      "epoch: 8200.00000 | total_loss:    0.11948 | domain_loss:    0.66461 | bdc_loss:    0.11397\n",
      "epoch: 8400.00000 | total_loss:    0.11178 | domain_loss:    0.69909 | bdc_loss:    0.10585\n",
      "epoch: 8600.00000 | total_loss:    0.10631 | domain_loss:    0.73397 | bdc_loss:    0.09997\n",
      "epoch: 8800.00000 | total_loss:    0.10198 | domain_loss:    0.76833 | bdc_loss:    0.09525\n",
      "epoch: 9000.00000 | total_loss:    0.09790 | domain_loss:    0.80019 | bdc_loss:    0.09080\n",
      "epoch: 9200.00000 | total_loss:    0.09329 | domain_loss:    0.81847 | bdc_loss:    0.08596\n",
      "epoch: 9400.00000 | total_loss:    0.08784 | domain_loss:    0.82484 | bdc_loss:    0.08040\n",
      "epoch: 9600.00000 | total_loss:    0.08185 | domain_loss:    0.81197 | bdc_loss:    0.07448\n",
      "epoch: 9800.00000 | total_loss:    0.07534 | domain_loss:    0.75606 | bdc_loss:    0.06847\n",
      "epoch: 10000.00000 | total_loss:    0.06838 | domain_loss:    0.66327 | bdc_loss:    0.06237\n",
      "epoch: 10200.00000 | total_loss:    0.06132 | domain_loss:    0.55026 | bdc_loss:    0.05638\n",
      "epoch: 10400.00000 | total_loss:    0.05477 | domain_loss:    0.43835 | bdc_loss:    0.05090\n",
      "epoch: 10600.00000 | total_loss:    0.04927 | domain_loss:    0.34455 | bdc_loss:    0.04629\n",
      "epoch: 10800.00000 | total_loss:    0.04503 | domain_loss:    0.27300 | bdc_loss:    0.04273\n",
      "epoch: 11000.00000 | total_loss:    0.04194 | domain_loss:    0.21938 | bdc_loss:    0.04015\n",
      "epoch: 11200.00000 | total_loss:    0.03974 | domain_loss:    0.17989 | bdc_loss:    0.03833\n",
      "epoch: 11400.00000 | total_loss:    0.03816 | domain_loss:    0.15168 | bdc_loss:    0.03702\n",
      "epoch: 11600.00000 | total_loss:    0.03701 | domain_loss:    0.13198 | bdc_loss:    0.03606\n",
      "epoch: 11800.00000 | total_loss:    0.03617 | domain_loss:    0.11883 | bdc_loss:    0.03534\n",
      "epoch: 12000.00000 | total_loss:    0.03556 | domain_loss:    0.11013 | bdc_loss:    0.03481\n",
      "epoch: 12200.00000 | total_loss:    0.03513 | domain_loss:    0.10431 | bdc_loss:    0.03443\n",
      "epoch: 12400.00000 | total_loss:    0.03483 | domain_loss:    0.10040 | bdc_loss:    0.03416\n",
      "epoch: 12600.00000 | total_loss:    0.03461 | domain_loss:    0.09764 | bdc_loss:    0.03397\n",
      "epoch: 12800.00000 | total_loss:    0.03445 | domain_loss:    0.09553 | bdc_loss:    0.03383\n",
      "epoch: 13000.00000 | total_loss:    0.03433 | domain_loss:    0.09384 | bdc_loss:    0.03373\n",
      "epoch: 13200.00000 | total_loss:    0.03423 | domain_loss:    0.09241 | bdc_loss:    0.03365\n",
      "epoch: 13400.00000 | total_loss:    0.03416 | domain_loss:    0.09121 | bdc_loss:    0.03358\n",
      "epoch: 13600.00000 | total_loss:    0.03409 | domain_loss:    0.09007 | bdc_loss:    0.03352\n",
      "epoch: 13800.00000 | total_loss:    0.03403 | domain_loss:    0.08908 | bdc_loss:    0.03347\n",
      "epoch: 14000.00000 | total_loss:    0.03397 | domain_loss:    0.08775 | bdc_loss:    0.03343\n",
      "epoch: 14200.00000 | total_loss:    0.03392 | domain_loss:    0.08657 | bdc_loss:    0.03339\n",
      "epoch: 14400.00000 | total_loss:    0.03388 | domain_loss:    0.08535 | bdc_loss:    0.03336\n",
      "epoch: 14600.00000 | total_loss:    0.03383 | domain_loss:    0.08402 | bdc_loss:    0.03332\n",
      "epoch: 14800.00000 | total_loss:    0.03379 | domain_loss:    0.08277 | bdc_loss:    0.03329\n",
      "epoch: 15000.00000 | total_loss:    0.03375 | domain_loss:    0.08150 | bdc_loss:    0.03327\n",
      "epoch: 15200.00000 | total_loss:    0.03371 | domain_loss:    0.08014 | bdc_loss:    0.03324\n",
      "epoch: 15400.00000 | total_loss:    0.03367 | domain_loss:    0.07845 | bdc_loss:    0.03321\n",
      "epoch: 15600.00000 | total_loss:    0.03363 | domain_loss:    0.07680 | bdc_loss:    0.03319\n",
      "epoch: 15800.00000 | total_loss:    0.03359 | domain_loss:    0.07521 | bdc_loss:    0.03317\n",
      "epoch: 16000.00000 | total_loss:    0.03355 | domain_loss:    0.07357 | bdc_loss:    0.03315\n",
      "epoch: 16200.00000 | total_loss:    0.03352 | domain_loss:    0.07190 | bdc_loss:    0.03313\n",
      "epoch: 16400.00000 | total_loss:    0.03348 | domain_loss:    0.07032 | bdc_loss:    0.03311\n",
      "epoch: 16600.00000 | total_loss:    0.03345 | domain_loss:    0.06938 | bdc_loss:    0.03309\n",
      "epoch: 16800.00000 | total_loss:    0.03341 | domain_loss:    0.06683 | bdc_loss:    0.03307\n",
      "epoch: 17000.00000 | total_loss:    0.03338 | domain_loss:    0.06513 | bdc_loss:    0.03306\n",
      "epoch: 17200.00000 | total_loss:    0.03334 | domain_loss:    0.06348 | bdc_loss:    0.03304\n",
      "epoch: 17400.00000 | total_loss:    0.03331 | domain_loss:    0.06228 | bdc_loss:    0.03302\n",
      "epoch: 17600.00000 | total_loss:    0.03328 | domain_loss:    0.06012 | bdc_loss:    0.03301\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.03325 | domain_loss:    0.05852 | bdc_loss:    0.03299\n",
      "epoch: 18000.00000 | total_loss:    0.03322 | domain_loss:    0.05699 | bdc_loss:    0.03298\n",
      "epoch: 18200.00000 | total_loss:    0.03319 | domain_loss:    0.05550 | bdc_loss:    0.03296\n",
      "epoch: 18400.00000 | total_loss:    0.03316 | domain_loss:    0.05388 | bdc_loss:    0.03295\n",
      "epoch: 18600.00000 | total_loss:    0.03313 | domain_loss:    0.05241 | bdc_loss:    0.03293\n",
      "epoch: 18800.00000 | total_loss:    0.03310 | domain_loss:    0.05124 | bdc_loss:    0.03292\n",
      "epoch: 19000.00000 | total_loss:    0.03308 | domain_loss:    0.04978 | bdc_loss:    0.03291\n",
      "epoch: 19200.00000 | total_loss:    0.03305 | domain_loss:    0.04827 | bdc_loss:    0.03290\n",
      "epoch: 19400.00000 | total_loss:    0.03303 | domain_loss:    0.04723 | bdc_loss:    0.03288\n",
      "epoch: 19600.00000 | total_loss:    0.03300 | domain_loss:    0.04601 | bdc_loss:    0.03287\n",
      "epoch: 19800.00000 | total_loss:    0.03298 | domain_loss:    0.04451 | bdc_loss:    0.03286\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0001), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03285974004096602"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean((uxy[0,:,:,0]-truth_data)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth':np.asarray(truth_smooth),\n",
    "                     'samples':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0)}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
